CONTENTS | INDEX | PREV | NEXT
FUNCTION
DICE Compiler Front End
SYNOPSIS
dcc options file file ...
DESCRIPTION
Dcc is the normal method of using the DICE system from a CLI window.
Dcc automatically invokes all the other parts of DICE, relieving you
of learning the grimy details. Dcc is similar to the UNIX cc
command. Many users will prefer to use VMake, the visual interface
to DICE. See chapter for full documentation.
Dcc options may occur anywhere on the command line but MUST occur
singly. That is, -c -a instead of -ca. file arguments to options may
occur with or without an intervening space. -oFILE and -o FILE are
both legal.
Files ending in .a or .asm are assumed to be assembly files. Files
ending in .l or .lib are assumed to be library files. Files ending
in .o or .obj are assumed to be object files. All other files are
assumed to be C source files.
Normally DCC compiles all C source files, assembles all asm files,
and links the resulting object files with any specified .o files
together to produce an executable. The output file may optionally be
specified with the -o option. If not specified, a default output
filename based on the name of the input file is generated. This
general action is modified by two options:
-c DCC does NOT link, -o specifies the output object file
-a DCC does NOT assemble (i.e. leaves the .a file resulting from a
compile). -o specifies the output assembly file
If neither option is given -o specifies the name of the resulting
executable.
The default object directory is T: and may be changed with the -O
option. The default temporary directory is also T: and may be
changed with the -T option. IF YOU HAVE LIMITED MEMORY you may
have to specify that temporary files not be placed in T: either
by re-assigning T: or using the -T option. DICE goes much slower
if temporary files must be written to a floppy or even a hard
disk.
## WARNING: asm files are assembled with DAS, See the assembler
## reference if you intend to assemble non-DC1 generated assembly
file File to compile, assemble (.a), and/or link (.o, .lib)
@@file containing further list of files, one per line. (blank lines and
lines beginning with ';' or '#' are ignored. File may NOT
contain further options).
E file specify stderr file, any errors are appended to file instead of
to stdout. Useful for batch compiles
-c Compile C source files and assemble into OBJECT files only (do
not link).
-a Compile C source files into ASSEMBLY files (do not assemble or
link).
Keep in mind the DAS will do further optimizations on the
assembly file that you see.
-l0 Skip linking default libraries (dlib:c.lib dlib:amigas.lib
dlib:auto.lib), or standard startup (dlib:c.o and dlib:x.o).
:: Beginner's Note: Do not use this option
This option is used in special circumstances, such as when
generating .libraries or .devices.
## WARNING: DICE is much more dependent on its startup code (c.o
## and x.o) than other compilers, do not link without the startup
## unless you know what you are doing.
-l lib Include this library when linking. (space is optional)
:: Beginner's Note: Use -lm to link with the math library. The
:: math library is required before functions such as printf will
:: work with floating point.
See chapter for more information on linking in custom
libraries.
0 -2.0 -1.3
Set the compiler to look for libraries and includes in the proper
place. Libraries and includes are different for each operating
system release. DICE eases compiling for, or using, different OS
versions. DICE inserts the revision number into library names
("amigas30.lib") and the include file path ("dinclude:amiga30/").
x -2.x -1.x
Like the above options, except x specifies a specific minor OS
revision.
-L0 remove default library search path, including all explicitly
specified (-L dir) directories up to this point.
-L dir add the specified directory to the library search path. If the
object module or library can not be found in the current
directory, directories specified with -L are searched. -L
directories are searched before the default library directory
(DLIB:), assuming it was not removed with -L0 .
Note that the directory path specified by -L is used to search
for libraries AND object modules.
A trailing '/' is optional
-I0 Remove default include path from search list. The default
include path is dinclude: and dinclude:amiga/ (unless modified by
-1.x and -2.x options)
-I dir When compiling scan this include directory (space is optional)
The specified path takes precedence over defaults but defaults
are NOT removed.
-D define[=value]
Pre-define a symbol
-U Undefine __STDC__, mc68000, _DCC, and AMIGA.
:: Beginner's Note: Do not use any of these options
-Houtfile=headerfile
This option enables precompiled header file generation and
operation. You may specify any number of -H options. Example
usage:
-Ht:defs.m=defs.h
When DICE encounters an #include <defs.h> this will cause it to
first check for the existence of T:DEFS.M ... if T:DEFS.M does
not exist DICE will generate it from <defs.h>. if T:DEFS.M does
exist then DICE will use it directly and ignore <defs.h>
You must specify the -H option both to have DICE create the
precompiled header file and to have DICE use the precompiled
header file. Normally one makes operation as transparent as
possible so as not depend on the option existing when porting to
other environments.
## WARNING: A precompiled header file contains the preprocessed
## header and preprocessor macros. These are set in stone!
If you modify a #define that would normally effect preprocessing
of a header file which is precompiled THE EFFECT WILL NOT OCCUR.
It is strongly suggested you use precompiled headers ONLY with
includes that are pretty much unchanging. For example, the
commodore includes or otherwise have an appropriate dependency in
your DMakefile or make script to delete the precompiled header
file whenever any of your headers are modified.
Normally one has a single -H option that enables precompiling of
a local header file, say defs.h, which contains #include's of all
other header files. Source modules would then #include <defs.h>
:: Beginner's Note: Do not use this option
-o file Specify output executable, object, or assembly file name
depending on what you are producing. The space is optional
-020 Generate code for the 68020 and later microprocessors
-030 Generate code for the 68030 and later microprocessors
-881 Generate inline FFP code for the 68881
-882 Generate inline FFP code for the 68882
:: Beginner's Note: Do not use any of these options
These options exist to produce 020 and 030 opcodes, and 881/882
inline assembly for floating point operations.
-md small data model (default) uses A4-relative
-mD large data model uses absolute-long
-mc small code model (default) uses PC-relative
-mC large code model uses absolute-long
:: Beginner's Note: Use only -mD if you declare more than
:: 64KBytes of data.
These options specify the default data and code model to use.
The model may be overridden by use of the __near and __far type
qualifiers on a variable by variable basis.
DICE defaults to the small data and small code model, and is able
to generate >32KBytes of code using the small code model so you
should never have to use -mC. Note that the DICE libraries have
all been compiled with the small-data model, and certain
applications may disrupt the base register, A4... in this case
use of the __geta4 type qualifier should be of use. If worse
comes to worse you can recompile a large-data model c.lib, but I
suggest you try other solutions first.
-ms0 (default), Only const objects are put into a CODE hunk
-ms String constants are put into the read-only code hunk
-mS String constants are put into the read-only code hunk AND all
external const references use NEAR addressing
:: Beginner's Note: Use only -ms
-ms0 turns off -ms/-mS in case you have it in your DCCOPTS
environment variable and want to turn it off.
Default operation (no -ms or -mS) puts const items into a
read-only CODE hunk. Locally declared objects are referenced
using PC-REL while external objects (declared in some other
module) are referenced using 32-BIT ABSOLUTE addressing.
-ms will additionally make all string constants, such as "fubar",
const and referenced via PC-REL. -ms is an extremely useful
option when you will never modify any of your string constants
because the strings are not copied for multiple running instances
of the program (if resident).
-mS works like -ms, but in addition forces all external const
references to use PC-REL addressing INSTEAD of 32-bit absolute
addressing.
|| NOTE: This is a very dangerous option, do not use unless the
|| final code size is less than 32 kbytes.
Using -ms along with -r can result in huge savings of memory due
to the string constants being moved out of the data segment
(which must be duplicated for each running instance of the
program).
## WARNING: In all cases if you declare an object as const it
## must be extern'd as const in other modules or incorrect code
## will be generated. This is true whether you use -ms/S or not.
-mRR registered arguments, strict
This option controls the automatic registerization of procedure
arguments. Only those prototyped procedures declaring 4 or fewer
arguments will be registered. Values are passed in D0/D1/A0/A1
according to the type of variable and availability of registers.
-mRR generates a single registerized entry point and extends
registerization to indirect function calls (that must be fully
prototyped).
-mRR assigns either the registered or normal entry point to
function pointers depending on whether they are prototyped or not
(and any calls made through these function pointers will use the
registered args method).
## WARNING: -mR cannot be used if you make c.lib calls that take
## call-back functions as arguments.
-mr and -mRR CAN be used, however with -mRR you must be careful
to supply the registered entry point.
## WARNING: AMIGA.LIB routines that take call-back functions as
## arguments must be given non-registered entry points.
Thus if you use -mRR you MUST qualify the procedure or function
pointer type specification with __stkargs to entire it has a
normal entry point.
-mw addr Used for making romable executables, Do not use to create AMIGA
executables
:: Beginner's Note: Do not use this option
This option is another data model, called the ABSOLUTE-WORD data
model. Source files compiled with this option generate
absolute-word data references to access data objects instead of
A4-relative or absolute-long. The base of the data segment must
be specified as decimal, 0octal, or 0xHEX.
Since absolute-word is used exclusive of A4-relative, the
compiler will now use A4 for register variables. You may NOT mix
-mw modules with small-data models.
The ROMABLE program is usually run on the executable generated by
DLink to generate a ROM.
-ma addr Used for making romable executables, do not use to create Amiga
executables
:: Beginner's Note: Do not use this option
This option specifies to the compiler and linker that the
resulting code is intended to be relocated to a permanent data
address, that specified by addr in decimal, 0octal, of 0xHEX.
Unlike -mw, -ma assumes that the data segment can be placed
anywhere. The ROMABLE program is usually run on the executable
generated by DLink to generate a ROM.
You may still specify a data model, -md or -mD, to Be with this
option. Unlike -mw, -ma does NOT touch the A4 register and thus
may be mixed with the small-data model. See the section on
generating Romable code.
-rom Set up options for generating romable code
:: Beginner's Note: Do not use this option
Like -l0, -rom disables automatic inclusion of a startup file
(you must specify your own) and libraries. However, x.o is still
included to sink any autoinit code. Your startup code must
handle the appropriate model and call autoinit code before
calling your program main
This option is used to support ROMed firmware, i.e. non-Amiga
executables. You should never link with c.lib. Instead, a new
library, rom.lib, is available.
rom.lib contains no static or global references and thus works
with any data model, and only completely self-contained routines
are included. The only data rom.lib uses is stack-based. All
rom.lib routines are completely reentrant, including [v]sprintf()
!
-proto Prototype checking and optimizations
When this option is used, an ERROR message will be generated for
any call that is not prototyped. This option is useful to ensure
that you have properly prototyped routines (when you use
prototypes), especially when floats and doubles are passed and
indirect function pointers are used (they must be prototyped as
well!).
In the future this will enable stack-argument optimization.
Currently, chars and shorts are extended to long's when pushed
onto the stack for a subroutine call. In the future if the
-proto option is used these objects will be pushed as shorts and
not extended.
-prof enable profiling for source modules
-prof1 same as -prof
-prof2 enable profiling for source modules and c*p.lib
-prof3 enable profiling for source mods, c*p.lib, and amiga*p.lib
Enable profiling. You may compile some or all your source
modules with profiling enabled. Any -prof* option will enable
profiling for compiled source modules. -prof2 will cause DCC to
link with a profiled c*p.lib while -prof3 will cause DCC to link
with a profiled c*p.lib and amiga*p.lib (the ultimate).
To profile c*.lib and/or amiga*.lib functions the equivalent
c*p.lib and amiga*p.lib must exist. These libraries are most
likely lharc'd in DCC2:dlib/ or DCC3:dlib/ but if not, registered
users may create any link library from the library source.
-r Make executable residentable with separate CODE & DATA hunks
-pr Make executable residentable w/ no relocation hunks
-pi Make executable NON-residentable w/ no relocation hunks
:: Beginner's Note: Just use -r to get residentable executables
:: and do not worry about these other options.
-pr/-pi generate 'position independent' code also useful for
ROMed applications. NOTE that -pi and -pr force const items to
be referenced pc-relative as well, causing -ms and -mS to do the
same thing (when combined with -pr/-pi)
Code size is limited to 32k bytes when you use -pr or -pi
Refer to the RESIDENTABILITY section in Chapter 5 for a
discussion of these options
|| NOTE: You may not make data references within const declared
|| objects when using the -r/-pr options.
This is because the CODE hunk is shared between running instances
of the program and these address references would be different
between the instances.
However, if you are using the -ms option, string constants will
be in the code section and thus no problem.
-O outdir Specify directory that is to contain output executable, object,
or assembly files (used when specifying multiple source files)
-O is useful to tell the compiler where to put the objects when
you use dcc to compile and link a whole bunch of files at once.
In this case, the -o option can still be used to specify where to
put the final executable.
|| NOTE: The -O name is used as a prefix so if you are specifying
|| a directory be sure it has a ':' or '/' on the end.
-R If the compile resulted in errors or warnings, execute the ARexx
script specified in dcc:config/dcc.config. This activates the
integrated error tracking features of DICE.
-T tmpdir Specify the temporary directory used to hold preprocessed source
files and temporary assembly files... files that will be deleted
after use.
|| NOTE: The -T name is used as a prefix so if you are specifying
|| a directory be sure it has a ':' or '/' on the end.
The default is T:. This option is useful in low-memory
situations where you may decide to put intermediate files
elsewhere. Putting intermediate files on your hard disc or
floppy slows down compilation by an order of magnitude, but if
you are running on a system with little memory you may not have a
choice.
-s Include symbolic debugging information in the executable (dlink
option).
This option includes the symbol table in the resulting executable
and is passed to dlink. When using DOBJ to disassemble an
executable, DOBJ will use the symbol table to generate a more
symbolic dump.
-S Alternate section naming op for libraries
When making libraries: uses alternate section naming conventions
so that all initialized data in the module will be placed before
any initialized data in non -S modules (i.e. normal linked
object files). Any library BSS will be placed before non-library
BSS. Thus, the final ordering in the final executable will be:
LIBDATA
PROGRAMDATA
LIBBSS
PROGRAMBSS
Thus, if your program contains >64K Bytes of BSS you can still
link with a library that tries to reference its own BSS using the
small-data model. If your library declares only initialized data
(i.e. int x = 0; ), then you can link with the library even if
your program declares >64KBytes of *initialized* data !
-v Display commands as DCC executes them.
-new Checks timestamps for source/destination and only
compiles/assembles if object is outdated or does not exist. Used
to make DCC a standalone make.
-f Fast CTRL-C handling for 1.3
This option is used for 1.3 only. You MUST be using the
Commodore shell (NewShell) and if you make programs resident you
MUST use the Commodore C:Resident command.
This option will probably not work if you use WShell or ARPShell
under 1.3. This option allows DICE to take short cuts to run
sub-programs and allows CTRL-C to be propagated to said programs.
This option is useful to set permanently in your DCCOPTS ENV:
variable if you run under 1.3. DICE under 2.0 has no such
problems and will run sub programs optimally, including
propagation of ^C.
-frag FRAGment (linker option).Quake People.. DICE was here first
Tell linker not to combine all code hunks together or combine all
data hunks together. Cannot be used if the -r or -mw options are
used. Generally only useful if the large-data model is used. Not
entirely supported yet.
-ffp Set fp library for floats
:: Beginner's Note: When using single precision floating point
:: this option, use of the original ffp libraries, will make the
:: program portable across all Amigas.
Otherwise only amigas that have the Commodore
MathIeeeSing*.library libraries will be able to run the program.
If not specified, mathieeesingtrans.library and
mathieeesingbas.library are used. These are new 2.0 libraries
that may not exist on all machines yet.
If specified, mathtrans.library is used .. Motorola's FFP float
library.
|| NOTE: IF -ffp is used, be warned that conversion from floats
|| to doubles and back again is not entirely reliable.
-d# Set debugging level (# = a number), used for compiler diagnostics
only.
-d opts Specify any combination of debugging options. These options may
be combined in one -d option.
Currently no options are defined.
-gs Generate Dynamic Stack Code. This generates code on every
subroutine call to check available stack. If available stack
falls below 2K a new stack frame is allocated which will be
deallocated when the subroutine returns.
If the allocation fails, stack_abort() is called. If this
routine is not defined by you, the library stack_abort() will
call abort().
This option is extremely useful when compiling UNIX code that
expects infinite stack.
-chip CHIP force (linker option).
Tell linker to force all hunks into CHIP memory. You should
generally not use this option. Instead, use the __chip keyword
for those specific data items that need to be in CHIP memory.
|| NOTE: CHIP data items are accessed using the large-data model,
|| thus you cannot create residentable executables that contain
|| __chip declarations Unless they are also const objects --
|| read-only.
-unix Causes DICE to use DLIB:uc*.lib instead of DLIB:c*.lib ... the
uc*.lib is exactly the same as the normal c*.lib except that all
filenames are assumed to be UNIX names .. that is, a beginning
slash is converted to ':' (root of the current volume), "./" is
ignored, and "../" is converted to "/" for all file accesses.
This makes porting and usage of UNIX programs easier.
-aztec The front end attempts to run Aztec executables
-sas -lattice
Identical. The front end attempts to run SAS/Lattice executables
These options allow one to write a single DMakefile able to
handle compilation under any compiler, assuming the source is
compilable under any compiler. These are very limited options
and may not work across new versions of Aztec or SAS/C
-// This option enables C++ style // comments. This form of
commenting begins with a // causing it and the remainder of the
line to be considered a comment.
-no-env This option disables DCCOPTS. DCC will not process options in
the DCCOPTS environment variable.
The ENV:DCCOPTS environment variable may contain additional
options.
ENV:must exist for DCC to run, even if you do not have a DCCOPTS
environment variable. If you do not use ENV:,assign it to RAM:
1> assign env: ram:
EXAMPLES:
Example #1. Compile hello.c to create executable "hello.":
1> dcc hello.c
1> hello
Example #2. Compile hello.c to executable "fish" and put the object
file in X:
1> dcc hello.c -o ram:fish -TX:
Example #3. Compile hello.c to and object file in RAM, then link
with symbols:
1> dcc -c hello.c -o ram:hello.o
1> dcc ram:hello.o -o ram:hello -s
Example #4. Compile foo.c and link with an already compiled object
file gar.o to produce an executable. foo.o is placed in T:
1> dcc foo.c gar.o -o ram:foogar
SEE ALSO
das, dc1, dcpp, dlink